import xlrd

from Common.Common_api2 import testcasedata_view
from Common.Common_random import *
from Common.Common_api2 import *
from Common.Common_authentication import *

from backend.common.assertapi import *
from Common.Common_statistics import *
from backend.common.common_db import *
from collections import Counter
"""
常规校验
"""
# 常规校验具有局限性（针对于都是字符串+能够进行赋值无限制的字段）
# 1.E收银短信接口，ipType 及 customId 是必填项；且值不可以随便赋值随机数； 此时第三步骤将所有的必填项赋予随机值，非必填项为空进行校验，无法执行；
# 2.E收银短信接口含有smsContent 是必填项且为列表类型，常规校验目前都是str进行赋值，当为list时，且为多个时，无法进行赋值，一旦赋值，Syntax error；

# view中的regular_check_seccess_data列表中包含所有执行成功得测试案例信息；
# 一个接口对应多个测试案例，有成功有失败得，成功得测试案例也包含里面；
# 因此列表里面得接口个数会多余interface_succcess_list；interface_succcess_list列表只统计此接口下得测试案例全部成功得接口；

def  regular_check_seccess_screen(regular_check_seccess_data,interface_succcess_list):

    for i in regular_check_seccess_data:
        if i[1]['interfaces_id'] not in interface_succcess_list:
            regular_check_seccess_data.remove(i)

        else:
            pass
    return regular_check_seccess_data


interface_res_result_list_totle = []  #作为整体返回值
def Regular_Check(interface_succcess_list, test_case_seccess_datas,interface_pici):  # 传参：执行成功得接口列表 + 接口成功得测试案例 + 批次号
    if len(interface_succcess_list) == 0: #没有成功
        pass
    elif len(interface_succcess_list) != 0:

        # 获取执行成功的接口名称列表
        interface_succcess_name = list_name(interface_succcess_list)


        for test_case_toll_datas in test_case_seccess_datas:

            interface_result = []  # 每个接口重新进行赋空值
            interface_result.append(test_case_toll_datas[1]['interfaces_id'])
            interface_result.append(test_case_toll_datas[2]['Querytestcases']['id'])

            case_type = test_case_toll_datas[2]['Querytestcases']['case_type']
            if case_type == "0":  # 常规校验测试
                book = xlrd.open_workbook(r'backend/excel_value/shuju.xlsx')
                sheet_name = book.sheet_names()
                # print(sheet_name)
                scene = []
                zhixingres = []
                bitian_feibitian_list = []

                for i in sheet_name:

                    sheet1 = book.sheet_by_name(i) ##先获取此页的接口名称，是否在interface_succcess_name里面
                    interace_name = sheet1.col_values(colx=0, start_rowx=2)
                    interace_name = [i for i in interace_name if i != ''][0]  # 如果合并单元格需要去除“”
                    # print("读取的接口名称为:%s"%interace_name)

                    # 补充案例

                    if interace_name not in interface_succcess_name: #场景一：存在多余表的情况时，不统计
                        extra_form = {}
                        # print("场景一：（多余表）读取的接口名称为:%s"%interace_name)
                        extra_form['1']="失败"
                        scene.append(extra_form)
                        zhixingres.append("失败")



                    # 场景二：存在表且等于当前读取的列表
                    elif interace_name in interface_succcess_name and interace_name == test_case_toll_datas[1]['interfaces_name']:
                        # print("场景二：（恰好等于）读取的接口名称为:%s" % interace_name)
                        extra_form = {}
                        extra_form['2'] = "成功"
                        scene.append(extra_form)


                        sheet_list_all = excel_data(sheet1)
                        # print("%s接口读取B-G数据：%s" % (interace_name,sheet_list_all)) #进行断言规则将文字转换成数字 等于=7

                        # 必填项依次为空  独立出来
                        # type_list = []
                        bitian_list = []  #zhixingres字段功能一致

                        for list_1 in sheet_list_all:
                            # type_list.append(list_1[1]) #类型追加到列表中；如果全部都不是str;进行一条提示报错信息,暂时先不管；
                            if list_1[1] == "str":

                                if list_1[2] == "1":
                                    # 2-1 必填项全部生成随机数
                                    test_case_toll_datas = random_data(sheet_list_all, test_case_toll_datas)
                                    # print("更新一遍必填项得总数据为test_case_toll_datas_1:%s"%test_case_toll_datas)

                                    # 2-2 依次必填项为空，并重新拼接获取测试案例
                                    testcasedata_datas = required_empty_data(list_1, test_case_toll_datas)
                                    # print('重新替换预期值，拼接后的数据为:%s' % testcasedata_datas)

                                    # 2-3认证判断+调http请求
                                    responseJson_ret = authentication_assert(testcasedata_datas)
                                    # print("实际response返回值为：%s" % responseJson_ret)

                                    #     2-4断言
                                    assert_response_list_all = carry_assert(testcasedata_datas['assert_response'],responseJson_ret)
                                    # print("接收实际的返回结果:%s" % assert_response_list_all)

                                    # 2-5 根据断言结果统计单个案例执行结果



                                    # 执行条件
                                    switch = testcasedata_datas['action_condition']
                                    test_case_result = test_case_judge(testcasedata_datas['assert_response'],switch)
                                    # print('此条案例id=%s的执行结果为%s' % (testcasedata_datas['testcases_id'], test_case_result))


                                    # 2-6存储结果 修改后进行存储执行结果（Lyzd_InterfaceCase_Action）：批次+接口名称+用例名称+校验内容+校验规则+预期值+实际返回值+执行结果

                                    check_key = list(testcasedata_datas['assert_response'].keys())[0]
                                    check_condition = list(testcasedata_datas['assert_response'][check_key].keys())[0]
                                    check_value = testcasedata_datas['assert_response'][check_key][check_condition]
                                    out_value = assert_response_list_all[0][1]
                                    interface_res = assert_response_list_all[0][2]

                                    # interface_res_list = []  # 接口执行结果汇总（必填+非必填）
                                    # interface_res_result_list = []  #[接口id,interface_res_list]
                                    # interface_res_list.append(interface_res)
                                    bitian_list.append(interface_res)

                                    # 存储数据
                                    interfacesId = Lyzd_Interface.objects.get(id=testcasedata_datas['interfaces_id'])
                                    testcaseId = Lyzd_Interface_Case.objects.get(id=testcasedata_datas['testcases_id'])
                                    statistics_testcase_result = InterfaceCase_Action.addInterfaceCaseAction(interface_pici,interfacesId,testcaseId,interace_name,
                                                                                testcasedata_datas['testcases_name'],check_key,check_condition,check_value,out_value, interface_res)





                                else:  # 非必填项保留（其他类型数据跳过验证）
                                    pass

                            else:  # 其他数据类型
                                pass



                        # 3.所有的选填项全部置空
                        # 3-1必填项全部设置为随机数
                        random_data_all = random_data(sheet_list_all, test_case_toll_datas)
                        # print("此时的随机数据为：%s"%random_data_all)

                        a = []
                        for i in sheet_list_all:
                            a.append(i[2])


                        if "0" in a: #存在必填项的话
                            for param_list in sheet_list_all:  # ['currency', 'str', '0', '', '', '']
                                if param_list[1] == "str":
                                    if param_list[2] == "0":  # 非空全部置空
                                        # 3-2需填写设置为空
                                        random_data_all[2]['Querytestcases']['param_testcase_data'][param_list[0]] = ''
                                        testcasedata_datas2 = testcasedata_view(random_data_all)

                                    else:
                                        pass

                                else:  # 其他类型
                                    pass

                            # 3-3 认证判断+调http请求
                            responseJson_ret = authentication_assert(testcasedata_datas2)
                            # print("实际返回值为：%s" % responseJson_ret)

                            # 3-4
                            assert_response_list_all = carry_assert(testcasedata_datas2['assert_response'],
                                                                    responseJson_ret)
                            # print("接收实际的返回结果:%s" % assert_response_list_all)

                            # 3-5
                            # 执行条件
                            switch = testcasedata_datas2['action_condition']
                            test_case_result = test_case_judge(testcasedata_datas2['assert_response'],switch)
                            # print('此条案例id=%s的执行结果为%s' % (testcasedata_datas2['testcases_id'], test_case_result))


                            # 3-6更新需求后进行存储数据（存储至用例汇总维度的表）

                            check_key = list(testcasedata_datas2['assert_response'].keys())[0]
                            check_condition = list(testcasedata_datas2['assert_response'][check_key].keys())[0]
                            check_value = testcasedata_datas2['assert_response'][check_key][check_condition]
                            out_value = assert_response_list_all[0][1]
                            interface_res = assert_response_list_all[0][2]
                            check_condition = check_condition_type(check_condition)  # 转换成中文展示在前端中
                            interfacesId = Lyzd_Interface.objects.get(id=testcasedata_datas2['interfaces_id'])
                            testcaseId = Lyzd_Interface_Case.objects.get(id=testcasedata_datas2['testcases_id'])
                            bitian_list.append(interface_res)


                            # 存储数据
                            statistics_testcase_result = InterfaceCase_Action.addInterfaceCaseAction(interface_pici,
                                                                                                     interfacesId,
                                                                                                     testcaseId,
                                                                                                     interace_name,
                                                                                                     testcasedata_datas2[
                                                                                                         'testcases_name'],
                                                                                                     check_key,
                                                                                                     check_condition,
                                                                                                     check_value,
                                                                                                     out_value,
                                                                                                     interface_res)


                            bitian_feibitian_list.append(bitian_list)




                        else: #全部是必填项
                            bitian_feibitian_list.append(bitian_list)
                            pass

                    # 场景三：存在接口但没有维护表信息
                    else:
                        # print("场景三：表中无此接口名称")
                        extra_form = {}
                        extra_form['3'] = "失败"
                        scene.append(extra_form)
                        zhixingres.append("失败")




                # 如果scene中含有场景二即不再添加场景三的提示失败数据
                scenes = []
                for i in scene:
                    scene1 = list(i.keys())
                    scenes.append(scene1)


                scenes2_list = []
                for m in scenes:
                    scenes2_list.append(m[0])

                if "2" in scenes2_list:
                    # print("此接口覆盖场景2，不再添加场景三提示信息")
                    pass


                elif "1" in scenes2_list:
                    count1 = Counter(scenes2_list)["1"]
                    lencount = len(scenes2_list)
                    if count1 == lencount:
                        # print("此处不添加至用例维度统计数据，后续有统计全是场景的1的情况")
                        pass



                else:
                    interface_name = test_case_toll_datas[1]['interfaces_name']
                    interface_case_name = test_case_toll_datas[2]['Querytestcases']['case_name']
                    check_key_lists = "None"
                    check_condition_lists = "None"
                    check_value_lists = "None"
                    out_value_lists = "None(失败原因：执行的接口没有维护常规校验数据)"
                    interface_res = "失败"

                    # print("批次:%s" % interface_pici)

                    interfaces_id = Lyzd_Interface.objects.get(id=test_case_toll_datas[1]['interfaces_id'])
                    testcase_id = Lyzd_Interface_Case.objects.get(id=test_case_toll_datas[2]['Querytestcases']['id'])
                    InterfaceCase_Action.addInterfaceCaseAction(interface_pici,
                                                                interfaces_id, testcase_id,
                                                                interface_name,
                                                                interface_case_name,
                                                                check_key_lists,
                                                                check_condition_lists,
                                                                check_value_lists, out_value_lists, interface_res)





                zhixingres.clear()  #场景一与场景三都是自定义的失败，将列表清空表示执行失败；

                interface_result.append(scene)
                interface_result.append( bitian_feibitian_list)



                interface_res_result_list_totle.append(interface_result)


            #     根据常规校验整体的执行结果来控制接口维度的统计结果（方法重写） 将结果进行返回

            else: #除了常规校验测试以外的类型!
                pass

    else:  #interface_succcess_list数据类型错误!
        pass


    return interface_res_result_list_totle

def list_name(interface_succcess_list):
    interface_succcess_name = []
    for interface_succcess in interface_succcess_list:
        interface_name = Interfaces.getInterfacesName(interface_succcess)
        interface_succcess_name.append(interface_name)

    return interface_succcess_name

# 读取表数据
def excel_data(sheet1):
    # 读取接口名称：获取整列A列从第三行开始
    interace_name = sheet1.col_values(colx=0, start_rowx=2)
    # 2-1 合并单元格，去除“”
    interace_name = [i for i in interace_name if i != ''][0]


    # 总行数
    rows_count = sheet1.nrows


# 4.获取整个接口的B-G的数值
    list_all = []
    start_rowx = 2
    for i in range(rows_count - 2):
        # 固定列数：B-G
        A_col3 = sheet1.row_values(start_rowx, 1, 7)
        list_all.append(A_col3)
        start_rowx += 1

    return list_all

# =1的全部生成随机数
def random_data(list_all,test_case_toll_datas):
    for list_1 in list_all:
        if list_1[1] == "str":
            if list_1[2] == "1":
                # 给必填项全部赋值，放置存在唯一性
                test_case_toll_datas[2]['Querytestcases']['param_testcase_data'][list_1[0]] = random_number_str(2)
        if list_1[1] == "list":
            # print("暂不处理列表，保留")
            pass
    return test_case_toll_datas



#遍历每一个必填项，分别为空，预期值拼接，校验，结果入库；
def  required_empty_data(list_1,test_case_toll_datas):



    test_case_toll_datas[2]['Querytestcases']['param_testcase_data'][list_1[0]] = ''
    testcasedata_datas = testcasedata_view(test_case_toll_datas)


    #          替换预期值；从表中读取数据进行替换  {'data': {'assertEqual': '{}'}}
    list_check_dict = {}
    list_li = {}
    list_li[list_1[4]] = list_1[5]
    list_check_dict[list_1[3]] = list_li
    testcasedata_datas['assert_response'] = list_check_dict

    return testcasedata_datas












